home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / nss / keyhi.h < prev    next >
C/C++ Source or Header  |  2006-04-20  |  9KB  |  291 lines
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  3.  *
  4.  * The contents of this file are subject to the Mozilla Public License Version
  5.  * 1.1 (the "License"); you may not use this file except in compliance with
  6.  * the License. You may obtain a copy of the License at
  7.  * http://www.mozilla.org/MPL/
  8.  *
  9.  * Software distributed under the License is distributed on an "AS IS" basis,
  10.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  11.  * for the specific language governing rights and limitations under the
  12.  * License.
  13.  *
  14.  * The Original Code is the Netscape security libraries.
  15.  *
  16.  * The Initial Developer of the Original Code is
  17.  * Netscape Communications Corporation.
  18.  * Portions created by the Initial Developer are Copyright (C) 1994-2000
  19.  * the Initial Developer. All Rights Reserved.
  20.  *
  21.  * Contributor(s):
  22.  *   Dr Stephen Henson <stephen.henson@gemplus.com>
  23.  *   Dr Vipul Gupta <vipul.gupta@sun.com>, Sun Microsystems Laboratories
  24.  *
  25.  * Alternatively, the contents of this file may be used under the terms of
  26.  * either the GNU General Public License Version 2 or later (the "GPL"), or
  27.  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  28.  * in which case the provisions of the GPL or the LGPL are applicable instead
  29.  * of those above. If you wish to allow use of your version of this file only
  30.  * under the terms of either the GPL or the LGPL, and not to allow others to
  31.  * use your version of this file under the terms of the MPL, indicate your
  32.  * decision by deleting the provisions above and replace them with the notice
  33.  * and other provisions required by the GPL or the LGPL. If you do not delete
  34.  * the provisions above, a recipient may use your version of this file under
  35.  * the terms of any one of the MPL, the GPL or the LGPL.
  36.  *
  37.  * ***** END LICENSE BLOCK ***** */
  38. /* $Id: keyhi.h,v 1.13 2005/09/02 01:24:42 wtchang%redhat.com Exp $ */
  39.  
  40. #ifndef _KEYHI_H_
  41. #define _KEYHI_H_
  42.  
  43. #include "plarena.h"
  44.  
  45. #include "seccomon.h"
  46. #include "secoidt.h"
  47. #include "secdert.h"
  48. #include "keythi.h"
  49. #include "certt.h"
  50. /*#include "secpkcs5.h" */
  51.  
  52. SEC_BEGIN_PROTOS
  53.  
  54.  
  55. /*
  56. ** Destroy a subject-public-key-info object.
  57. */
  58. extern void SECKEY_DestroySubjectPublicKeyInfo(CERTSubjectPublicKeyInfo *spki);
  59.  
  60. /*
  61. ** Copy subject-public-key-info "src" to "dst". "dst" is filled in
  62. ** appropriately (memory is allocated for each of the sub objects).
  63. */
  64. extern SECStatus SECKEY_CopySubjectPublicKeyInfo(PRArenaPool *arena,
  65.                          CERTSubjectPublicKeyInfo *dst,
  66.                          CERTSubjectPublicKeyInfo *src);
  67.  
  68. /*
  69. ** Update the PQG parameters for a cert's public key.
  70. ** Only done for DSA and Fortezza certs
  71. */
  72. extern SECStatus
  73. SECKEY_UpdateCertPQG(CERTCertificate * subjectCert);
  74.  
  75.  
  76. /* Compare the KEA parameters of two public keys.  
  77.  * Only used by fortezza.      */
  78.  
  79. extern SECStatus
  80. SECKEY_KEAParamCompare(CERTCertificate *cert1,CERTCertificate *cert2);
  81.  
  82. /*
  83. ** Return the strength of the public key in bytes
  84. */
  85. extern unsigned SECKEY_PublicKeyStrength(SECKEYPublicKey *pubk);
  86.  
  87. /*
  88. ** Return the strength of the public key in bits
  89. */
  90. extern unsigned SECKEY_PublicKeyStrengthInBits(SECKEYPublicKey *pubk);
  91.  
  92. /*
  93. ** Make a copy of the private key "privKey"
  94. */
  95. extern SECKEYPrivateKey *SECKEY_CopyPrivateKey(SECKEYPrivateKey *privKey);
  96.  
  97. /*
  98. ** Make a copy of the public key "pubKey"
  99. */
  100. extern SECKEYPublicKey *SECKEY_CopyPublicKey(SECKEYPublicKey *pubKey);
  101.  
  102. /*
  103. ** Convert a private key "privateKey" into a public key
  104. */
  105. extern SECKEYPublicKey *SECKEY_ConvertToPublicKey(SECKEYPrivateKey *privateKey);
  106.  
  107. /*
  108.  * create a new RSA key pair. The private Key is returned...
  109.  */
  110. SECKEYPrivateKey *SECKEY_CreateRSAPrivateKey(int keySizeInBits,
  111.                        SECKEYPublicKey **pubk, void *cx);
  112.     
  113. /*
  114.  * create a new DH key pair. The private Key is returned...
  115.  */
  116. SECKEYPrivateKey *SECKEY_CreateDHPrivateKey(SECKEYDHParams *param,
  117.                        SECKEYPublicKey **pubk, void *cx);
  118.  
  119. /*
  120.  * create a new EC key pair. The private Key is returned...
  121.  */
  122. SECKEYPrivateKey *SECKEY_CreateECPrivateKey(SECKEYECParams *param,
  123.                                            SECKEYPublicKey **pubk, void *cx);
  124.  
  125. /*
  126. ** Create a subject-public-key-info based on a public key.
  127. */
  128. extern CERTSubjectPublicKeyInfo *
  129. SECKEY_CreateSubjectPublicKeyInfo(SECKEYPublicKey *k);
  130.  
  131. /*
  132. ** Decode a DER encoded public key into an SECKEYPublicKey structure.
  133. */
  134. extern SECKEYPublicKey *SECKEY_DecodeDERPublicKey(SECItem *pubkder);
  135.  
  136. /*
  137. ** Convert a base64 ascii encoded DER public key to our internal format.
  138. */
  139. extern SECKEYPublicKey *SECKEY_ConvertAndDecodePublicKey(char *pubkstr);
  140.  
  141. /*
  142. ** Convert a base64 ascii encoded DER public key and challenge to spki,
  143. ** and verify the signature and challenge data are correct
  144. */
  145. extern CERTSubjectPublicKeyInfo *
  146. SECKEY_ConvertAndDecodePublicKeyAndChallenge(char *pkacstr, char *challenge,
  147.                                 void *cx);
  148.  
  149. /*
  150. ** Encode a  CERTSubjectPublicKeyInfo structure. into a
  151. ** DER encoded subject public key info. 
  152. */
  153. SECItem *
  154. SECKEY_EncodeDERSubjectPublicKeyInfo(SECKEYPublicKey *pubk);
  155.  
  156. /*
  157. ** Decode a DER encoded subject public key info into a
  158. ** CERTSubjectPublicKeyInfo structure.
  159. */
  160. extern CERTSubjectPublicKeyInfo *
  161. SECKEY_DecodeDERSubjectPublicKeyInfo(SECItem *spkider);
  162.  
  163. /*
  164. ** Convert a base64 ascii encoded DER subject public key info to our
  165. ** internal format.
  166. */
  167. extern CERTSubjectPublicKeyInfo *
  168. SECKEY_ConvertAndDecodeSubjectPublicKeyInfo(char *spkistr);
  169.  
  170. /*
  171.  * extract the public key from a subject Public Key info structure.
  172.  * (used by JSS).
  173.  */
  174. extern SECKEYPublicKey *
  175. SECKEY_ExtractPublicKey(CERTSubjectPublicKeyInfo *);
  176.  
  177. /*
  178. ** Destroy a private key object.
  179. **    "key" the object
  180. */
  181. extern void SECKEY_DestroyPrivateKey(SECKEYPrivateKey *key);
  182.  
  183.  
  184. /*
  185. ** Destroy a public key object.
  186. **    "key" the object
  187. */
  188. extern void SECKEY_DestroyPublicKey(SECKEYPublicKey *key);
  189.  
  190. /* Destroy and zero out a private key info structure.  for now this
  191.  * function zero's out memory allocated in an arena for the key 
  192.  * since PORT_FreeArena does not currently do this.  
  193.  *
  194.  * NOTE -- If a private key info is allocated in an arena, one should 
  195.  * not call this function with freeit = PR_FALSE.  The function should 
  196.  * destroy the arena.  
  197.  */
  198. extern void
  199. SECKEY_DestroyPrivateKeyInfo(SECKEYPrivateKeyInfo *pvk, PRBool freeit);
  200.  
  201. /* Destroy and zero out an encrypted private key info.
  202.  *
  203.  * NOTE -- If a encrypted private key info is allocated in an arena, one should 
  204.  * not call this function with freeit = PR_FALSE.  The function should 
  205.  * destroy the arena.  
  206.  */
  207. extern void
  208. SECKEY_DestroyEncryptedPrivateKeyInfo(SECKEYEncryptedPrivateKeyInfo *epki,
  209.                       PRBool freeit);
  210.  
  211. /* Copy private key info structure.  
  212.  *  poolp is the arena into which the contents of from is to be copied.
  213.  *    NULL is a valid entry.
  214.  *  to is the destination private key info
  215.  *  from is the source private key info
  216.  * if either from or to is NULL or an error occurs, SECFailure is 
  217.  * returned.  otherwise, SECSuccess is returned.
  218.  */
  219. extern SECStatus
  220. SECKEY_CopyPrivateKeyInfo(PRArenaPool *poolp,
  221.               SECKEYPrivateKeyInfo *to,
  222.               SECKEYPrivateKeyInfo *from);
  223.  
  224. extern SECStatus
  225. SECKEY_CacheStaticFlags(SECKEYPrivateKey* key);
  226.  
  227. /* Copy encrypted private key info structure.  
  228.  *  poolp is the arena into which the contents of from is to be copied.
  229.  *    NULL is a valid entry.
  230.  *  to is the destination encrypted private key info
  231.  *  from is the source encrypted private key info
  232.  * if either from or to is NULL or an error occurs, SECFailure is 
  233.  * returned.  otherwise, SECSuccess is returned.
  234.  */
  235. extern SECStatus
  236. SECKEY_CopyEncryptedPrivateKeyInfo(PRArenaPool *poolp,
  237.                    SECKEYEncryptedPrivateKeyInfo *to,
  238.                    SECKEYEncryptedPrivateKeyInfo *from);
  239. /*
  240.  * Accessor functions for key type of public and private keys.
  241.  */
  242. KeyType SECKEY_GetPrivateKeyType(SECKEYPrivateKey *privKey);
  243. KeyType SECKEY_GetPublicKeyType(SECKEYPublicKey *pubKey);
  244.  
  245. /*
  246.  * Creates a PublicKey from its DER encoding.
  247.  * Currently only supports RSA and DSA keys.
  248.  */
  249. SECKEYPublicKey*
  250. SECKEY_ImportDERPublicKey(SECItem *derKey, CK_KEY_TYPE type);
  251.  
  252. SECKEYPrivateKeyList*
  253. SECKEY_NewPrivateKeyList(void);
  254.  
  255. void
  256. SECKEY_DestroyPrivateKeyList(SECKEYPrivateKeyList *keys);
  257.  
  258. void
  259. SECKEY_RemovePrivateKeyListNode(SECKEYPrivateKeyListNode *node);
  260.  
  261. SECStatus
  262. SECKEY_AddPrivateKeyToListTail( SECKEYPrivateKeyList *list,
  263.                                 SECKEYPrivateKey *key);
  264.  
  265. #define PRIVKEY_LIST_HEAD(l) ((SECKEYPrivateKeyListNode*)PR_LIST_HEAD(&l->list))
  266. #define PRIVKEY_LIST_NEXT(n) ((SECKEYPrivateKeyListNode *)n->links.next)
  267. #define PRIVKEY_LIST_END(n,l) (((void *)n) == ((void *)&l->list))
  268.  
  269. SECKEYPublicKeyList*
  270. SECKEY_NewPublicKeyList(void);
  271.  
  272. void
  273. SECKEY_DestroyPublicKeyList(SECKEYPublicKeyList *keys);
  274.  
  275. void
  276. SECKEY_RemovePublicKeyListNode(SECKEYPublicKeyListNode *node);
  277.  
  278. SECStatus
  279. SECKEY_AddPublicKeyToListTail( SECKEYPublicKeyList *list,
  280.                                 SECKEYPublicKey *key);
  281.  
  282. #define PUBKEY_LIST_HEAD(l) ((SECKEYPublicKeyListNode*)PR_LIST_HEAD(&l->list))
  283. #define PUBKEY_LIST_NEXT(n) ((SECKEYPublicKeyListNode *)n->links.next)
  284. #define PUBKEY_LIST_END(n,l) (((void *)n) == ((void *)&l->list))
  285.  
  286. extern int SECKEY_ECParamsToKeySize(const SECItem *params);
  287.  
  288. SEC_END_PROTOS
  289.  
  290. #endif /* _KEYHI_H_ */
  291.